﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;
//using ArgusPCLib.Mathematics.Reflection;

//namespace ArgusPCLib.Mathematics
//{
//	public class Complex<T> : IScalar
//		where T:ILinearScalar
//	{
//		#region Fields
//		T re;
//		T im;
//		#endregion

//		#region Constructors
//		private Complex(T re, T im, bool copy)
//		{
//			if (copy == true)
//			{
//				this.re = (T)re.GetCopy();
//				this.im = (T)im.GetCopy();
//			}
//			else
//			{
//				this.re = re;
//				this.im = im;
//			}
//		}

//		public Complex(Complex<T> c)
//			: this(c.re, c.im) { }

//		public Complex(T re, T im)
//			: this(re, im, true) { }

//		public Complex(T re)
//			: this(re, ScalarReflector<T>.Zero) { }

//		public Complex()
//			: this(ScalarReflector<T>.One, ScalarReflector<T>.Zero) { }

//		public Complex(Vector<T> vec)
//			:this(vec[0], vec[1])
//		{
//			if (vec.Dimension != 2)
//				throw new DimensionException();
//		}
//		#endregion

//		#region Properties
//		public static Complex<T> Zero { get { return new Complex<T>(); } }
//		public static Complex<T> One { get { return new Complex<T>(ScalarReflector<T>.One, ScalarReflector<T>.Zero, false); } }
//		public T Real { get { return (T)this.re.GetDeepCopy(); } }
//		public T Imagenary { get { return (T)this.im.GetDeepCopy(); } }
//		#endregion

//		#region Public Methods
//		public Vector<T> ToVector()
//		{
//			return new Vector<T>(this.re, this.im);
//		}

//		public T RadiusSquared()
//		{
//			return (T)this.re.Multiply(this.re).Add(this.im.Multiply(this.im));
//		}
//		#endregion

//		#region Static Methods
//		public static Complex<T> Conjugate(Complex<T> c)
//		{
//			return new Complex<T>((T)c.re.GetCopy(), (T)TZero.Subtract(c.im), false);
//		}
//		#endregion

//		#region Operators
//		public static bool operator==(Complex<T> a, Complex<T> b)
//		{
//			return (a.re.IsEqualTo(b.re) && a.im.IsEqualTo(b.im));
//		}

//		public static bool operator!=(Complex<T> a, Complex<T> b)
//		{
//			return (!a.re.IsEqualTo(b.re) || !a.im.IsEqualTo(b.im));
//		}

//		public static Complex<T> operator +(Complex<T> a, Complex<T> b)
//		{
//			return new Complex<T>((T)a.re.Add(b.re), (T)a.im.Add(b.im), false);
//		}

//		public static Complex<T> operator -(Complex<T> a, Complex<T> b)
//		{
//			return new Complex<T>((T)a.re.Subtract(b.re), (T)a.im.Subtract(b.im), false);
//		}

//		public static Complex<T> operator *(Complex<T> a, Complex<T> b)
//		{
//			IScalar re = a.re.Multiply(b.re);
//			re = re.Subtract(a.im.Multiply(b.im));
//			IScalar im = a.re.Multiply(b.im);
//			im = im.Add(a.im.Multiply(b.re));
//			return new Complex<T>((T)re, (T)im, false);
//		}

//		public static Complex<T> operator /(Complex<T> a, Complex<T> b)
//		{
//			if (b.re.IsEqualTo(TZero) == true && b.im.IsEqualTo(TZero) == true)
//				throw new DivideByZeroException();
//			IScalar den = b.RadiusSquared();
//			IScalar re = a.re.Multiply(b.re);
//			re = re.Add(a.im.Multiply(b.im));
//			re = re.Divide(den);
//			IScalar im = a.im.Multiply(b.re);
//			im = im.Subtract(a.re.Multiply(b.im));
//			im = im.Divide(den);
//			return new Complex<T>((T)re, (T)im, false);
//		}
//		#endregion

//		#region Implicit Casts
//		public static implicit operator Complex<T>(T re)
//		{
//			return new Complex<T>(re);
//		}

//		public static implicit operator Vector<T>(Complex<T> c)
//		{
//			return c.ToVector();
//		}
//		#endregion

//		#region Explicit Casts
//		public static explicit operator Complex<T>(Vector<T> vec)
//		{
//			if (vec.Dimension != 2)
//				throw new DimensionException();
//			return new Complex<T>(vec);
//		}
//		#endregion

//		#region IScalar
//		string IFormattable.ToString(string format, IFormatProvider formatProvider)
//		{
//			throw new NotImplementedException();
//		}

//		bool IScalar.IsEqualTo(IScalar scalar)
//		{
//			return (this == (Complex<T>)scalar);
//		}

//		IScalar IScalar.Divide(IScalar scalar)
//		{
//			return (this / (Complex<T>)scalar);
//		}

//		IScalar IScalar.Subtract(IScalar scalar)
//		{
//			return (this - (Complex<T>)scalar);
//		}

//		IScalar IScalar.Multiply(IScalar scalar)
//		{
//			return (this * (Complex<T>)scalar);
//		}

//		IScalar IScalar.Add(IScalar scalar)
//		{
//			return (this + (Complex<T>)scalar);
//		}

//		IOperand IOperand.GetDeepCopy()
//		{
//			return new Complex<T>(this);
//		}
//		#endregion
//	}
//}
